using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("RenderToTexture")]
	public class RenderToTexture : MonoBehaviour
	{
		public enum RenderToTextureMaterial
		{
			Custom,
			Transparent,
			Additive,
			Bloom,
			AlphaClip,
			AlphaClipBloom
		}

		public enum AlphaClipShader
		{
			Standard,
			ColorGradient
		}

		public enum BloomRenderType
		{
			Color,
			Alpha
		}

		public enum BloomBlendType
		{
			Additive,
			Transparent
		}

		public static string BLUR_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "BLUR_SHADER_NAME");

		public static string BLUR_ALPHA_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "BLUR_ALPHA_SHADER_NAME");

		public static string ALPHA_BLEND_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_BLEND_SHADER_NAME");

		public static string ALPHA_BLEND_ADD_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_BLEND_ADD_SHADER_NAME");

		public static string ALPHA_FILL_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_FILL_SHADER_NAME");

		public static string BLOOM_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "BLOOM_SHADER_NAME");

		public static string BLOOM_ALPHA_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "BLOOM_ALPHA_SHADER_NAME");

		public static string ADDITIVE_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ADDITIVE_SHADER_NAME");

		public static string TRANSPARENT_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "TRANSPARENT_SHADER_NAME");

		public static string ALPHA_CLIP_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_CLIP_SHADER_NAME");

		public static string ALPHA_CLIP_BLOOM_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_CLIP_BLOOM_SHADER_NAME");

		public static string ALPHA_CLIP_GRADIENT_SHADER_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RenderToTexture", "ALPHA_CLIP_GRADIENT_SHADER_NAME");

		public static float OFFSET_DISTANCE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "OFFSET_DISTANCE");

		public static float MIN_OFFSET_DISTANCE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "MIN_OFFSET_DISTANCE");

		public static float MAX_OFFSET_DISTANCE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "MAX_OFFSET_DISTANCE");

		public Vector3 ALPHA_OBJECT_OFFSET => method_2<Vector3>("ALPHA_OBJECT_OFFSET");

		public static float RENDER_SIZE_QUALITY_LOW => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "RENDER_SIZE_QUALITY_LOW");

		public static float RENDER_SIZE_QUALITY_MEDIUM => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "RENDER_SIZE_QUALITY_MEDIUM");

		public static float RENDER_SIZE_QUALITY_HIGH => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "RENDER_SIZE_QUALITY_HIGH");

		public List<Vector2> PLANE_UVS => method_3<Class250<Vector2>>("PLANE_UVS")?.method_25();

		public List<Vector3> PLANE_NORMALS => method_3<Class250<Vector3>>("PLANE_NORMALS")?.method_25();

		public List<int> PLANE_TRIANGLES => method_3<Class250<int>>("PLANE_TRIANGLES")?.method_25();

		public GameObject m_ObjectToRender => method_3<GameObject>("m_ObjectToRender");

		public GameObject m_AlphaObjectToRender => method_3<GameObject>("m_AlphaObjectToRender");

		public bool m_HideRenderObject => method_2<bool>("m_HideRenderObject");

		public bool m_RealtimeRender => method_2<bool>("m_RealtimeRender");

		public bool m_RealtimeTranslation => method_2<bool>("m_RealtimeTranslation");

		public bool m_RenderMeshAsAlpha => method_2<bool>("m_RenderMeshAsAlpha");

		public bool m_OpaqueObjectAlphaFill => method_2<bool>("m_OpaqueObjectAlphaFill");

		public RenderToTextureMaterial m_RenderMaterial => method_2<RenderToTextureMaterial>("m_RenderMaterial");

		public Material m_Material => method_3<Material>("m_Material");

		public bool m_CreateRenderPlane => method_2<bool>("m_CreateRenderPlane");

		public GameObject m_RenderToObject => method_3<GameObject>("m_RenderToObject");

		public string m_ShaderTextureName => method_4("m_ShaderTextureName");

		public int m_Resolution => method_2<int>("m_Resolution");

		public float m_Width => method_2<float>("m_Width");

		public float m_Height => method_2<float>("m_Height");

		public float m_NearClip => method_2<float>("m_NearClip");

		public float m_FarClip => method_2<float>("m_FarClip");

		public float m_BloomIntensity => method_2<float>("m_BloomIntensity");

		public float m_BloomThreshold => method_2<float>("m_BloomThreshold");

		public float m_BloomBlur => method_2<float>("m_BloomBlur");

		public float m_BloomResolutionRatio => method_2<float>("m_BloomResolutionRatio");

		public BloomRenderType m_BloomRenderType => method_2<BloomRenderType>("m_BloomRenderType");

		public float m_BloomAlphaIntensity => method_2<float>("m_BloomAlphaIntensity");

		public BloomBlendType m_BloomBlend => method_2<BloomBlendType>("m_BloomBlend");

		public Color m_BloomColor => method_2<Color>("m_BloomColor");

		public AlphaClipShader m_AlphaClipRenderStyle => method_2<AlphaClipShader>("m_AlphaClipRenderStyle");

		public float m_AlphaClip => method_2<float>("m_AlphaClip");

		public float m_AlphaClipIntensity => method_2<float>("m_AlphaClipIntensity");

		public float m_AlphaClipAlphaIntensity => method_2<float>("m_AlphaClipAlphaIntensity");

		public float m_BlurAmount => method_2<float>("m_BlurAmount");

		public bool m_BlurAlphaOnly => method_2<bool>("m_BlurAlphaOnly");

		public Color m_TintColor => method_2<Color>("m_TintColor");

		public int m_RenderQueueOffset => method_2<int>("m_RenderQueueOffset");

		public int m_RenderQueue => method_2<int>("m_RenderQueue");

		public Color m_ClearColor => method_2<Color>("m_ClearColor");

		public string m_ReplacmentTag => method_4("m_ReplacmentTag");

		public string m_AlphaReplacementTag => method_4("m_AlphaReplacementTag");

		public Vector3 m_PositionOffset => method_2<Vector3>("m_PositionOffset");

		public Vector3 m_CameraOffset => method_2<Vector3>("m_CameraOffset");

		public LayerMask m_LayerMask => method_2<LayerMask>("m_LayerMask");

		public bool m_UniformWorldScale => method_2<bool>("m_UniformWorldScale");

		public float m_OverrideCameraSize => method_2<float>("m_OverrideCameraSize");

		public bool m_LateUpdate => method_2<bool>("m_LateUpdate");

		public bool m_RenderOnStart => method_2<bool>("m_RenderOnStart");

		public bool m_RenderOnEnable => method_2<bool>("m_RenderOnEnable");

		public bool m_renderEnabled => method_2<bool>("m_renderEnabled");

		public bool m_init => method_2<bool>("m_init");

		public float m_WorldWidth => method_2<float>("m_WorldWidth");

		public float m_WorldHeight => method_2<float>("m_WorldHeight");

		public Vector3 m_WorldScale => method_2<Vector3>("m_WorldScale");

		public GameObject m_OffscreenGameObject => method_3<GameObject>("m_OffscreenGameObject");

		public GameObject m_CameraGO => method_3<GameObject>("m_CameraGO");

		public Camera m_Camera => method_3<Camera>("m_Camera");

		public GameObject m_AlphaCameraGO => method_3<GameObject>("m_AlphaCameraGO");

		public Camera m_AlphaCamera => method_3<Camera>("m_AlphaCamera");

		public GameObject m_BloomCaptureCameraGO => method_3<GameObject>("m_BloomCaptureCameraGO");

		public Camera m_BloomCaptureCamera => method_3<Camera>("m_BloomCaptureCamera");

		public GameObject m_PlaneGameObject => method_3<GameObject>("m_PlaneGameObject");

		public GameObject m_BloomPlaneGameObject => method_3<GameObject>("m_BloomPlaneGameObject");

		public GameObject m_BloomCapturePlaneGameObject => method_3<GameObject>("m_BloomCapturePlaneGameObject");

		public bool m_ObjectToRenderOrgPositionStored => method_2<bool>("m_ObjectToRenderOrgPositionStored");

		public Transform m_ObjectToRenderOrgParent => method_3<Transform>("m_ObjectToRenderOrgParent");

		public Vector3 m_ObjectToRenderOrgPosition => method_2<Vector3>("m_ObjectToRenderOrgPosition");

		public Vector3 m_OriginalRenderPosition => method_2<Vector3>("m_OriginalRenderPosition");

		public bool m_isDirty => method_2<bool>("m_isDirty");

		public Vector3 m_OffscreenPos => method_2<Vector3>("m_OffscreenPos");

		public Vector3 m_ObjectToRenderOffset => method_2<Vector3>("m_ObjectToRenderOffset");

		public Vector3 m_AlphaObjectToRenderOffset => method_2<Vector3>("m_AlphaObjectToRenderOffset");

		public RenderToTextureMaterial m_PreviousRenderMaterial => method_2<RenderToTextureMaterial>("m_PreviousRenderMaterial");

		public List<Renderer> m_OpaqueObjectAlphaFillTransparent => method_3<Class271<Renderer>>("m_OpaqueObjectAlphaFillTransparent")?.method_25();

		public List<UberText> m_OpaqueObjectAlphaFillUberText => method_3<Class271<UberText>>("m_OpaqueObjectAlphaFillUberText")?.method_25();

		public Vector3 m_Offset => method_2<Vector3>("m_Offset");

		public static Vector3 s_offset => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "RenderToTexture", "s_offset");

		public Material m_AlphaBlendMaterial => method_3<Material>("m_AlphaBlendMaterial");

		public Material m_AlphaBlendAddMaterial => method_3<Material>("m_AlphaBlendAddMaterial");

		public Material m_AdditiveMaterial => method_3<Material>("m_AdditiveMaterial");

		public Material m_BloomMaterial => method_3<Material>("m_BloomMaterial");

		public Material m_BloomMaterialAlpha => method_3<Material>("m_BloomMaterialAlpha");

		public Material m_BlurMaterial => method_3<Material>("m_BlurMaterial");

		public Material m_AlphaBlurMaterial => method_3<Material>("m_AlphaBlurMaterial");

		public Material m_TransparentMaterial => method_3<Material>("m_TransparentMaterial");

		public Material m_AlphaClipMaterial => method_3<Material>("m_AlphaClipMaterial");

		public Material m_AlphaClipBloomMaterial => method_3<Material>("m_AlphaClipBloomMaterial");

		public Material m_AlphaClipGradientMaterial => method_3<Material>("m_AlphaClipGradientMaterial");

		public Vector3 Offset => method_11<Vector3>("get_Offset", Array.Empty<object>());

		public Material AlphaBlendMaterial => method_14<Material>("get_AlphaBlendMaterial", Array.Empty<object>());

		public Material AlphaBlendAddMaterial => method_14<Material>("get_AlphaBlendAddMaterial", Array.Empty<object>());

		public Material AdditiveMaterial => method_14<Material>("get_AdditiveMaterial", Array.Empty<object>());

		public Material BloomMaterial => method_14<Material>("get_BloomMaterial", Array.Empty<object>());

		public Material BloomMaterialAlpha => method_14<Material>("get_BloomMaterialAlpha", Array.Empty<object>());

		public Material BlurMaterial => method_14<Material>("get_BlurMaterial", Array.Empty<object>());

		public Material AlphaBlurMaterial => method_14<Material>("get_AlphaBlurMaterial", Array.Empty<object>());

		public Material TransparentMaterial => method_14<Material>("get_TransparentMaterial", Array.Empty<object>());

		public Material AlphaClipMaterial => method_14<Material>("get_AlphaClipMaterial", Array.Empty<object>());

		public Material AlphaClipBloomMaterial => method_14<Material>("get_AlphaClipBloomMaterial", Array.Empty<object>());

		public Material AlphaClipGradientMaterial => method_14<Material>("get_AlphaClipGradientMaterial", Array.Empty<object>());

		public RenderToTexture(IntPtr address, string className)
			: base(address, className)
		{
		}

		public RenderToTexture(IntPtr address)
			: this(address, "RenderToTexture")
		{
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void LateUpdate()
		{
			method_8("LateUpdate");
		}

		public void OnApplicationFocus(bool state)
		{
			method_8("OnApplicationFocus", state);
		}

		public void OnDrawGizmos()
		{
			method_8("OnDrawGizmos");
		}

		public void OnDisable()
		{
			method_8("OnDisable");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void OnEnable()
		{
			method_8("OnEnable");
		}

		public void ForceTextureRebuild()
		{
			method_8("ForceTextureRebuild");
		}

		public void Show()
		{
			method_9("Show", new Class276.Enum20[0]);
		}

		public void Show(bool render)
		{
			method_9("Show", new Class276.Enum20[1] { Class276.Enum20.Boolean }, render);
		}

		public void Hide()
		{
			method_8("Hide");
		}

		public void SetDirty()
		{
			method_8("SetDirty");
		}

		public Material GetRenderMaterial()
		{
			return method_14<Material>("GetRenderMaterial", Array.Empty<object>());
		}

		public GameObject GetRenderToObject()
		{
			return method_14<GameObject>("GetRenderToObject", Array.Empty<object>());
		}

		public Vector3 GetOffscreenPosition()
		{
			return method_11<Vector3>("GetOffscreenPosition", Array.Empty<object>());
		}

		public Vector3 GetOffscreenPositionOffset()
		{
			return method_11<Vector3>("GetOffscreenPositionOffset", Array.Empty<object>());
		}

		public void Init()
		{
			method_8("Init");
		}

		public void RenderTex()
		{
			method_8("RenderTex");
		}

		public void RenderBloom()
		{
			method_8("RenderBloom");
		}

		public void SetupForRender()
		{
			method_8("SetupForRender");
		}

		public void SetupMaterial()
		{
			method_8("SetupMaterial");
		}

		public void PositionHiddenObjectsAndCameras()
		{
			method_8("PositionHiddenObjectsAndCameras");
		}

		public void RestoreAfterRender()
		{
			method_8("RestoreAfterRender");
		}

		public void CreateTexture()
		{
			method_8("CreateTexture");
		}

		public void ReleaseTexture()
		{
			method_8("ReleaseTexture");
		}

		public void CreateCamera()
		{
			method_8("CreateCamera");
		}

		public float OrthoSize()
		{
			return method_11<float>("OrthoSize", Array.Empty<object>());
		}

		public void CameraRender()
		{
			method_8("CameraRender");
		}

		public void CreateAlphaCamera()
		{
			method_8("CreateAlphaCamera");
		}

		public void AlphaCameraRender()
		{
			method_8("AlphaCameraRender");
		}

		public void CreateBloomCaptureCamera()
		{
			method_8("CreateBloomCaptureCamera");
		}

		public Vector2 CalcTextureSize()
		{
			return method_11<Vector2>("CalcTextureSize", Array.Empty<object>());
		}

		public void CreateRenderPlane()
		{
			method_8("CreateRenderPlane");
		}

		public void CreateBloomPlane()
		{
			method_8("CreateBloomPlane");
		}

		public void CreateBloomCapturePlane()
		{
			method_8("CreateBloomCapturePlane");
		}

		public GameObject CreateMeshPlane(string name, Material material)
		{
			return method_14<GameObject>("CreateMeshPlane", new object[2] { name, material });
		}

		public void CalcWorldWidthHeightScale()
		{
			method_8("CalcWorldWidthHeightScale");
		}

		public void CleanUp()
		{
			method_8("CleanUp");
		}
	}
}
